package br.com.duosoftware.orcamento.managedbeans;

import br.com.duosoftware.orcamento.daos.AlineaDAO;
import br.com.duosoftware.orcamento.daos.CategoriaEconomicaDeReceitaDAO;
import br.com.duosoftware.orcamento.daos.EspecieDAO;
import br.com.duosoftware.orcamento.daos.OrigemDAO;
import br.com.duosoftware.orcamento.daos.PlanoDeReceitaDAO;
import br.com.duosoftware.orcamento.daos.RubricaDAO;
import br.com.duosoftware.orcamento.daos.SublineaDAO;
import br.com.duosoftware.orcamento.daos.TipoPlanoDeReceitaDAO;
import br.com.duosoftware.orcamento.entidades.Alinea;
import br.com.duosoftware.orcamento.entidades.CategoriaEconomicaDeReceita;
import br.com.duosoftware.orcamento.entidades.Especie;
import br.com.duosoftware.orcamento.entidades.Origem;
import br.com.duosoftware.orcamento.entidades.PlanoDeReceita;
import br.com.duosoftware.orcamento.entidades.Rubrica;
import br.com.duosoftware.orcamento.entidades.Sublinea;
import br.com.duosoftware.orcamento.entidades.TipoPlanoDeReceita;
import br.com.duosoftware.orcamento.services.PlanoDeReceitaService;
import br.com.duosoftware.orcamento.utils.Mensagens;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.model.SelectItem;
import org.hibernate.exception.ConstraintViolationException;
import org.primefaces.context.RequestContext;

/**
 *
 * @author Daniel
 *
 */
@ManagedBean
@ViewScoped
public class PlanoDeReceitaBean implements Serializable {

    private PlanoDeReceita planoDeReceita;
    private List<PlanoDeReceita> planosDeReceita;
    private PlanoDeReceitaDAO planoDeReceitaDAO;
    private PlanoDeReceitaService planoDeReceitaService;
    //
    private List<SelectItem> categoriasEconomicaDeReceita;
    private List<SelectItem> origens;
    private List<SelectItem> especies;
    private List<SelectItem> rubricas;
    private List<SelectItem> alineas;
    private List<SelectItem> sublineas;
    private List<SelectItem> tiposPlanoDeReceita;

    public PlanoDeReceitaBean() {

        planoDeReceitaService = new PlanoDeReceitaService();

        planoDeReceitaDAO = new PlanoDeReceitaDAO();

    }

    public PlanoDeReceita getPlanoDeReceita() {
        return planoDeReceita;
    }

    public void setPlanoDeReceita(PlanoDeReceita planoDeReceita) {
        this.planoDeReceita = planoDeReceita;
    }

    public List<PlanoDeReceita> getPlanosDeReceita() {
        if (planosDeReceita == null) {
            planosDeReceita = planoDeReceitaDAO.listarPlanosDeReceita();
        }
        return planosDeReceita;
    }

    public void setPlanosDeReceita(List<PlanoDeReceita> planosDeReceita) {
        this.planosDeReceita = planosDeReceita;
    }

    public PlanoDeReceitaService getPlanoDeReceitaService() {
        return planoDeReceitaService;
    }

    /**
     * <b>Método que inicializa a planoDeReceita a ser cadastrado.</b><p>
     *
     * @return void
     *
     */
    public void adicionarInicio() {

        planoDeReceita = new PlanoDeReceita();

    }

    /**
     * <b>Método que adiciona ou edita uma PlanoDeReceita</b><p>
     *
     * Após o término o método fecha o dialog de cadastro.
     * <p>
     *
     * @return void
     *
     */
    public void adicionarEditarFim() {

        planoDeReceitaDAO.salvarOuAtualizar(planoDeReceita);
        planoDeReceita = new PlanoDeReceita();
        planosDeReceita = null;

        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgPlanoDeReceita.hide()");
        requestContext.update("formPlanosDeReceita:dtPlanosDeReceita");

    }

    /**
     * <b>Método para iniciar o processo de edição de um PlanoDeReceita.</b>
     * <p>
     *
     * Ele verifica se há um PlanoDeReceita selecionada para edição, se não
     * houver é emitida uma mensagem pedindo que o usuário selecione uma.<p>
     *
     * Caso haja um PlanoDeReceita selecionado o médoto abre o dialog para
     * edição<p>
     *
     * @return void
     *
     */
    public void editarInicio() {

        if (planoDeReceita == null) {

            Mensagens.mensagemDeAlerta("Selecione um registro", "Selecione um re"
                    + "gistro para Editar");

        } else {

            RequestContext.getCurrentInstance().execute("dlgPlanoDeReceita.show()");

        }

    }

    /**
     * <b>Método para iniciar o processo de exclusão de um PlanoDeReceita.</b>
     * <p>
     *
     * Ele verifica se há uma PlanoDeReceita selecionado para exclusão, se não
     * houver é emitida uma mensagem pedindo que o usuário selecione uma.<p>
     *
     * Caso haja um PlanoDeReceita selecionado o médoto abre um p:dialog para
     * confirma ção da exclusão.<p>
     *
     * @return void
     *
     */
    public void excluirInicio() {

        if (planoDeReceita == null) {
            Mensagens.mensagemDeAlerta("Selecione um registro",
                    "Selecione um registro para excluir");
        } else {
            RequestContext.getCurrentInstance()
                    .execute("dlgExcluirPlanoDeReceita.show()");
        }

    }

    /**
     * <b>Método para excluir um PlanoDeReceita.</b>
     * <p>
     *
     * Ele verifica se a PlanoDeReceita selecionado para exclusão está sendo
     * utilizado por alguma outra tabela do banco. Se estiver uma mensagem de
     * aviso é dada ao usuário<p>
     *
     * @return void
     *
     */
    public void excluirFim() {

        try {

            planoDeReceitaDAO.excluir(planoDeReceita);
            planoDeReceita = new PlanoDeReceita();
            planosDeReceita = null;

        } catch (ConstraintViolationException e) {
            Mensagens.mensagemDeAlerta("Registro Utilizado",
                    "Esse registro está sendo utilizado");
        }

        RequestContext.getCurrentInstance()
                .execute("dlgExcluirPlanoDeReceita.hide()");

    }

    /**
     * <b> Método para cancelar uma operação de cadastro ou edição.</b>
     * <p>
     *
     * O método instancia um novo objeto na variável PlanoDeReceita para limpar
     * as infomações.<p>
     *
     * @return void
     */
    public void cancelar() {

        planoDeReceita = new PlanoDeReceita();

        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgPlanoDeReceita.hide()");
        requestContext.update("formPlanoDeReceita:dtPlanosDeReceita");

    }

    // Chamadas para metodos do Service
    public void obterSequencia() {

        if (planoDeReceita.getId() == null) {

            planoDeReceitaService.obterSequencia(planoDeReceita);
             
        }

    }

    public void obterClassificacao() {

        planoDeReceitaService.obterClassificacao(planoDeReceita);

    }

    public void obterDescricaoSubAlinea() {

        planoDeReceitaService.obterDescricaoSubAlinea(planoDeReceita);

    }

    //*************************get SelectItem********************************
    public List<SelectItem> getCategoriasEconomicaDeReceita() {

        if (categoriasEconomicaDeReceita == null) {

            categoriasEconomicaDeReceita = new LinkedList<SelectItem>();

            for (CategoriaEconomicaDeReceita categoria
                    : new CategoriaEconomicaDeReceitaDAO().
                    listarCategoriasEconomicaDeReceita()) {

                categoriasEconomicaDeReceita.add(new SelectItem(categoria,
                        categoria.toString()));

            }

        }

        return categoriasEconomicaDeReceita;

    }

    public List<SelectItem> getOrigens() {

        if (planoDeReceita.getCategoriaEconomicaDeReceita() != null) {

            origens = new LinkedList<SelectItem>();

            for (Origem origem : new OrigemDAO()
                    .listarOrigens(planoDeReceita.getCategoriaEconomicaDeReceita())) {

                origens.add(new SelectItem(origem, origem.toString()));

            }

        }

        return origens;

    }

    public List<SelectItem> getEspecies() {

        if (planoDeReceita.getOrigem() != null) {

            especies = new LinkedList<SelectItem>();

            for (Especie especie : new EspecieDAO()
                    .listarEspecies(planoDeReceita.getOrigem())) {

                especies.add(new SelectItem(especie, especie.toString()));

            }

        }

        return especies;

    }

    public List<SelectItem> getRubricas() {

        if (planoDeReceita.getEspecie() != null) {

            rubricas = new LinkedList<SelectItem>();

            for (Rubrica rubrica : new RubricaDAO()
                    .listarRubricas(planoDeReceita.getEspecie())) {

                rubricas.add(new SelectItem(rubrica, rubrica.toString()));

            }

        }

        return rubricas;

    }

    public List<SelectItem> getAlineas() {

        if (planoDeReceita.getRubrica() != null) {

            alineas = new LinkedList<SelectItem>();

            for (Alinea alinea : new AlineaDAO()
                    .listarAlineas(planoDeReceita.getRubrica())) {

                alineas.add(new SelectItem(alinea, alinea.toString()));

            }

        }

        return alineas;
    }

    public List<SelectItem> getSublineas() {

        if (planoDeReceita.getAlinea() != null) {

            sublineas = new LinkedList<SelectItem>();

            for (Sublinea sublinea : new SublineaDAO()
                    .listarSublineas(planoDeReceita.getAlinea())) {

                sublineas.add(new SelectItem(sublinea, sublinea.toString()));

            }

        }

        return sublineas;
    }

    public List<SelectItem> getTiposPlanoDeReceita() {

        if (tiposPlanoDeReceita == null) {

            tiposPlanoDeReceita = new LinkedList<SelectItem>();

            for (TipoPlanoDeReceita tipo : new TipoPlanoDeReceitaDAO()
                    .listarTiposPlanoDeReceita()) {

                tiposPlanoDeReceita.add(new SelectItem(tipo, tipo.toString()));

            }

        }

        return tiposPlanoDeReceita;

    }

}
